home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 4_0 / ZIP_SOUR / ZIPNOTE.C < prev    next >
C/C++ Source or Header  |  1992-01-13  |  10KB  |  353 lines
  1. /*
  2.  
  3.  Copyright (C) 1990,1991 Mark Adler, Richard B. Wales, and Jean-loup Gailly.
  4.  Permission is granted to any individual or institution to use, copy, or
  5.  redistribute this software so long as all of the original files are included
  6.  unmodified, that it is not sold for profit, and that this copyright notice
  7.  is retained.
  8.  
  9. */
  10.  
  11. /*
  12.  *  zipnote.c by Mark Adler.
  13.  */
  14.  
  15. #define UTIL
  16. #include "revision.h"
  17. #include "zip.h"
  18. #include <signal.h>
  19.  
  20.  
  21. /* Character to mark zip entry names in the comment file */
  22. #define MARK '@'
  23.  
  24. /* Temporary zip file name and file pointer */
  25. local char *tempzip;
  26. local FILE *tempzf;
  27.  
  28.  
  29. /* Local functions */
  30. #ifdef PROTO
  31.    local void err(int, char *);
  32.    local void handler(int);
  33.    local void license(void);
  34.    local void help(void);
  35.    local void putclean(char *);
  36.    local int catalloc(char * far *, char *);
  37.    void main(int, char **);
  38. #endif /* PROTO */
  39.  
  40.  
  41.  
  42. local void err(c, h)
  43. int c;                  /* error code from the ZE_ class */
  44. char *h;                /* message about how it happened */
  45. /* Issue a message for the error, clean up files and memory, and exit. */
  46. {
  47.   if (PERR(c))
  48.     perror("zipnote error");
  49.   fprintf(stderr, "zipnote error: %s (%s)\n", errors[c-1], h);
  50.   if (tempzf != NULL)
  51.     fclose(tempzf);
  52.   if (tempzip != NULL)
  53.   {
  54.     destroy(tempzip);
  55.     free((voidp *)tempzip);
  56.   }
  57.   if (zipfile != NULL)
  58.     free((voidp *)zipfile);
  59. #ifdef VMS
  60.   exit(0);
  61. #else /* !VMS */
  62.   exit(c);
  63. #endif /* ?VMS */
  64. }
  65.  
  66.  
  67. local void handler(s)
  68. int s;                  /* signal number (ignored) */
  69. /* Upon getting a user interrupt, abort cleanly using err(). */
  70. {
  71. #ifndef MSDOS
  72.   putc('\n', stderr);
  73. #endif /* !MSDOS */
  74.   err(ZE_ABORT, "aborting");
  75.   s++;                                  /* keep some compilers happy */
  76. }
  77.  
  78.  
  79. void warn(a, b)
  80. char *a, *b;            /* message strings juxtaposed in output */
  81. /* Print a warning message to stderr and return. */
  82. {
  83.   fprintf(stderr, "zipnote warning: %s%s\n", a, b);
  84. }
  85.  
  86.  
  87. local void license()
  88. /* Print license information to stdout. */
  89. {
  90.   extent i;             /* counter for copyright array */
  91.  
  92.   for (i = 0; i < sizeof(copyright)/sizeof(char *); i++)
  93.     puts(copyright[i]);
  94.   for (i = 0; i < sizeof(disclaimer)/sizeof(char *); i++)
  95.     puts(disclaimer[i]);
  96. }
  97.  
  98.  
  99. local void help()
  100. /* Print help (along with license info) to stdout. */
  101. {
  102.   extent i;             /* counter for help array */
  103.  
  104.   /* help array */
  105.   static char *text[] = {
  106. "",
  107. "ZipNote %d.%d (%s)",
  108. "Usage:  zipnote [-w] [-b path] zipfile",
  109. "  the default action is to write the comments in zipfile to stdout",
  110. "  -w   write the zipfile comments from stdin",
  111. "  -b   use \"path\" for the temporary zip file",
  112. "  -h   show this help               -l   show software license",
  113. "",
  114. "Example:",
  115. #ifdef VMS
  116. "     define/user sys$output foo.tmp",
  117. "     zipnote foo.zip",
  118. "     edit foo.tmp",
  119. "     ... then you edit the comments, save, and exit ...",
  120. "     define/user sys$input foo.tmp",
  121. "     zipnote -w foo.zip"
  122. #else /* !VMS */
  123. "     zipnote foo.zip > foo.tmp",
  124. "     ed foo.tmp",
  125. "     ... then you edit the comments, save, and exit ...",
  126. "     zipnote -w foo.zip < foo.tmp"
  127. #endif /* ?VMS */
  128.   };
  129.  
  130.   for (i = 0; i < sizeof(copyright)/sizeof(char *); i++)
  131.     puts(copyright[i]);
  132.   for (i = 0; i < sizeof(text)/sizeof(char *); i++)
  133.   {
  134.     printf(text[i], REVISION / 10, REVISION % 10, REVDATE);
  135.     putchar('\n');
  136.   }
  137. }
  138.  
  139.  
  140. local void putclean(s)
  141. char *s;                /* string to write to stdout */
  142. /* Write the string s to stdout, filtering out control characters that are
  143.    not tab or newline (mainly to remove carriage returns), and prefix MARK's
  144.    and backslashes with a backslash.  Also, terminate with a newline if
  145.    needed. */
  146. {
  147.   int c;                /* next character in string */
  148.   int e;                /* last character written */
  149.  
  150.   e = '\n';                     /* if empty, write nothing */
  151.   while ((c = *s++) != 0)
  152.   {
  153.     if (c == MARK || c == '\\')
  154.       putchar('\\');
  155.     if (c >= ' ' || c == '\t' || c == '\n')
  156.       putchar(e = c);
  157.   }
  158.   if (e != '\n')
  159.     putchar('\n');
  160. }
  161.  
  162.  
  163. local int catalloc(a, s)
  164. char * far *a;          /* pointer to a pointer to a malloc'ed string */
  165. char *s;                /* string to concatenate on a */
  166. /* Concatentate the string s to the malloc'ed string pointed to by a.
  167.    Preprocess s by removing backslash escape characters. */
  168. {
  169.   char *p;              /* temporary pointer */
  170.   char *q;              /* temporary pointer */
  171.  
  172.   for (p = q = s; *q; *p++ = *q++)
  173.     if (*q == '\\' && *(q+1))
  174.       q++;
  175.   *p = 0;
  176.   if ((p = malloc(strlen(*a) + strlen(s) + 3)) == NULL)
  177.     return ZE_MEM;
  178.   strcat(strcat(strcpy(p, *a), **a ? "\r\n" : ""), s);
  179.   free((voidp *)*a);
  180.   *a = p;
  181.   return ZE_OK;
  182. }
  183.  
  184.  
  185. void main(argc, argv)
  186. int argc;               /* number of tokens in command line */
  187. char **argv;            /* command line tokens */
  188. /* Write the comments in the zipfile to stdout, or read them from stdin. */
  189. {
  190.   char a[FNMAX+1];      /* input line buffer */
  191.   ulg c;                /* start of central directory */
  192.   int k;                /* next argument type */
  193.   char *q;              /* steps through option arguments */
  194.   int r;                /* arg counter, temporary variable */
  195.   ulg s;                /* length of central directory */
  196.   int t;                /* attributes of zip file */
  197.   int w;                /* true if updating zip file from stdin */
  198.   FILE *x, *y;          /* input and output zip files */
  199.   struct zlist far *z;  /* steps through zfiles linked list */
  200.  
  201.  
  202.   /* If no args, show help */
  203.   if (argc == 1)
  204.   {
  205.     help();
  206.     exit(0);
  207.   }
  208.  
  209.   /* Go through args */
  210.   zipfile = tempzip = NULL;
  211.   tempzf = NULL;
  212.   signal(SIGINT, handler);
  213.   signal(SIGTERM, handler);
  214.   k = w = 0;
  215.   for (r = 1; r < argc; r++)
  216.     if (*argv[r] == '-')
  217.       if (argv[r][1])
  218.         for (q = argv[r]+1; *q; q++)
  219.           switch(*q)
  220.           {
  221.             case 'b':   /* Specify path for temporary file */
  222.               if (k)
  223.                 err(ZE_PARMS, "use -b before zip file name");
  224.               else
  225.                 k = 1;          /* Next non-option is path */
  226.               break;
  227.             case 'h':   /* Show help */
  228.               help();  exit(0);
  229.             case 'l':   /* Show copyright and disclaimer */
  230.               license();  exit(0);
  231.             case 'w':
  232.               w = 1;  break;
  233.             default:
  234.               err(ZE_PARMS, "unknown option");
  235.           }
  236.       else
  237.         err(ZE_PARMS, "zip file cannot be stdin");
  238.     else
  239.       if (k == 0)
  240.         if (zipfile == NULL)
  241.         {
  242.           if ((zipfile = ziptyp(argv[r])) == NULL)
  243.             err(ZE_MEM, "was processing arguments");
  244.         }
  245.         else
  246.           err(ZE_PARMS, "can only specify one zip file");
  247.       else
  248.       {
  249.         tempath = argv[r];
  250.         k = 0;
  251.       }
  252.   if (zipfile == NULL)
  253.     err(ZE_PARMS, "need to specify zip file");
  254.  
  255.   /* Read zip file */
  256.   if ((r = readzipfile()) != ZE_OK)
  257.     err(r, zipfile);
  258.   if (zfiles == NULL)
  259.     err(ZE_NAME, zipfile);
  260.  
  261.   /* Put comments to stdout, if not -u */
  262.   if (!w)
  263.   {
  264.     for (z = zfiles; z != NULL; z = z->nxt)
  265.     {
  266.       printf("%c %s\n", MARK, z->zname);
  267.       if (z->com)
  268.         putclean(z->comment);
  269.       putchar(MARK);  putchar('\n');
  270.     }
  271.     putchar(MARK);  putchar('\n');
  272.     if (zcomlen)
  273.       putclean(zcomment);
  274.     exit(ZE_OK);
  275.   }
  276.  
  277.   /* If updating comments, make sure zip file is writeable */
  278.   if ((x = fopen(zipfile, "a")) == NULL)
  279.     err(ZE_CREAT, zipfile);
  280.   fclose(x);
  281.   t = getfileattr(zipfile);
  282.  
  283.   /* Process stdin, replacing comments */
  284.   for (z = zfiles; z != NULL; z = z->nxt)
  285.   {
  286.     if (gets(a) == NULL || a[0] != MARK || a[1] != ' ' ||
  287.         strcmp(a + 2, z->zname))
  288.       err(ZE_NOTE, "missing entry name");
  289.     if (z->com)
  290.       free((voidp *)z->comment);
  291.     z->comment = malloc(1);  *(z->comment) = 0;
  292.     while (gets(a) != NULL && *a != MARK)
  293.       if ((r = catalloc(&(z->comment), a)) != ZE_OK)
  294.         err(r, "was building new comments");
  295.     if (a[1])
  296.       err(ZE_NOTE, "missing comment end line");
  297.     z->com = strlen(z->comment);
  298.   }
  299.   if (gets(a) == NULL || a[0] != MARK || a[1])
  300.     err(ZE_NOTE, "missing zip file comment marker line");
  301.   zcomment = malloc(1);  *zcomment = 0;
  302.   while (gets(a) != NULL)
  303.     if ((r = catalloc(&zcomment, a)) != ZE_OK)
  304.       err(r, "was building new comments");
  305.   zcomlen = strlen(zcomment);
  306.  
  307.   /* Open output zip file for writing */
  308.   if ((tempzf = y = fopen(tempzip = tempname('Z'), FOPW)) == NULL)
  309.     err(ZE_TEMP, tempzip);
  310.  
  311.   /* Open input zip file again, copy preamble if any */
  312.   if ((x = fopen(zipfile, FOPR)) == NULL)
  313.     err(ZE_NAME, zipfile);
  314.   if (zipbeg && (r = fcopy(x, y, zipbeg)) != ZE_OK)
  315.     err(r, r == ZE_TEMP ? tempzip : zipfile);
  316.  
  317.   /* Go through local entries, copying them over as is */
  318.   for (z = zfiles; z != NULL; z = z->nxt)
  319.     if ((r = zipcopy(z, x, y)) != ZE_OK)
  320.       err(r, "was copying an entry");
  321.   fclose(x);
  322.  
  323.   /* Write central directory and end of central directory with new comments */
  324.   if ((c = ftell(y)) == -1L)    /* get start of central */
  325.     err(ZE_TEMP, tempzip);
  326.   for (z = zfiles; z != NULL; z = z->nxt)
  327.     if ((r = putcentral(z, y)) != ZE_OK)
  328.       err(r, tempzip);
  329.   if ((s = ftell(y)) == -1L)    /* get end of central */
  330.     err(ZE_TEMP, tempzip);
  331.   s -= c;                       /* compute length of central */
  332.   if ((r = putend((int)zcount, s, c, zcomlen, zcomment, y)) != ZE_OK)
  333.     err(r, tempzip);
  334.   tempzf = NULL;
  335.   if (fclose(y))
  336.     err(ZE_TEMP, tempzip);
  337.   if ((r = replace(zipfile, tempzip)) != ZE_OK)
  338.   {
  339.     warn("new zip file left as: ", tempzip);
  340.     free((voidp *)tempzip);
  341.     tempzip = NULL;
  342.     err(r, "was replacing the original zip file");
  343.   }
  344.   free((voidp *)tempzip);
  345.   tempzip = NULL;
  346.   setfileattr(zipfile, t);
  347.   free((voidp *)zipfile);
  348.   zipfile = NULL;
  349.  
  350.   /* Done! */
  351.   exit(ZE_OK);
  352. }
  353.